EgaLabs / node-ejsception

"use strict";

// :: DEPENDENCIES

// load native dependencies

const path = require("path");

const root = path.dirname(path.dirname(__dirname));

// global variables

const noStr   = [{}, true, false, 42, 3.1416, -42, -3.1416, () => null];

const noNmb   = [{}, true, false, '', "qwerty", () => null];

const name    = "qwerty";

const message = "asdf";

if (typeof Symbol === "function") {

    noStr.push(Symbol("symbol"));

    noNmb.push(Symbol("symbol"));

}

module.exports = (hierarchy) => {

    // check parameters

    if (!Array.isArray(hierarchy)) {

        throw new Error("hierarchy must be an array");

    }

    // load dependencies

    let deps      = hierarchy.map(value => require(path.join(root, value + ".js")));

    let klassName = hierarchy.pop();

    let Klass     = deps.pop();

    const first   = (hierarchy.length === 0);

    const third   = (hierarchy.length >= 3);

    // :: TESTING

    // test the last class in the hierarchy tree

    describe(klassName, () => {

        // :: INHERITED PROTOTYPE

        // all inherit from Object

        it("should inherit from 'Object'", () => {

            expect(new Klass()).toEqual(jasmine.any(Object));

        });

        // check the hierarchy tree

        for (let i = 0; i < hierarchy.length; i += 1) {

            it("should inherit from '" + hierarchy[i] + "'", () => {

                expect(new Klass()).toEqual(jasmine.any(deps[i]));

            });

        }

        // check inherited properties

        if (!first) {

            it("should have a prototype property named 'name'", () => {

                expect(Klass.prototype).toHaveString("name");

            });

            it("should have a prototype property named 'message'", () => {

                expect(Klass.prototype).toHaveString("message");

            });

            it("should have a prototype property named 'code'", () => {

                expect(Klass.prototype).toHaveMember("code");

            });

        }

        // check Object methods

        it("should have a prototype method named 'toString()'", () => {

            expect(Klass.prototype).toHaveMethod("toString");

        });

        // check inherited methods

        if (!first) {

            it("should have a prototype method named 'native()'", () => {

                expect(Klass.prototype).toHaveMethod("native");

            });

        }

        // :: EXTENDED PROTOTYPE

        // check extended properties

        if (first) {

            it("should have a prototype property named 'name'", () => {

                expect(Klass.prototype).toHaveString("name");

            });

            it("should have a prototype property named 'message'", () => {

                expect(Klass.prototype).toHaveString("message");

            });

            it("should have a prototype property named 'code'", () => {

                expect(Klass.prototype).toHaveMember("code");

            });

            it("should have a prototype method named 'native()'", () => {

                expect(Klass.prototype).toHaveMethod("native");

            });

        }

        // :: PROTOTYPE VALUES

        it("should have the 'class' name in the prototype property named 'name'", () => {

            expect(Klass.prototype.name).toEqual(klassName);

        });

        it("should have a dummy default value as message", () => {

            expect(Klass.prototype.message).toEqual("thrown");

        });

        it("should have a null default value as code", () => {

            expect(Klass.prototype.code).toBeNull();

        });

        // :: CONSTRUCTOR

        it("should instantiate without parameters", () => {

            instanceNoParameters(Klass, testNoErrors, third);

            testNoErrors(() => new Klass());

        });

        it("should instantiate with parameters", () => {

            instanceParameters(Klass, testNoErrors, testNoErrors, testNoErrors, third);

        });

        // use the tests according to the hierarchy level

        if (third) {

            testThird(Klass);

        } else {

            test(Klass);

        }

    });

};

// Tests that a function doesn't throw any Error

function testNoErrors(fn) {

    expect(fn).not.toThrowError("parameter 'name' must be a 'string'");

    expect(fn).not.toThrowError("parameter 'message' must be a 'string'");

    expect(fn).not.toThrowError("parameter 'code' must be a 'number'");

}

// Tests instantiation of a class without parameters (undefined, null or none).

function instanceNoParameters(Klass, fn, third) {

    let arg1, arg2, arg3, test;

    test = (() => new Klass(arg1, arg2, arg3));

    for (let i = 0; i < 2; i += 1) {

        arg1 = (i % 2 === 0 ? undefined : null);

        for (let j = 0; j < 2; j += 1) {

            arg2 = (j % 2 === 0 ? undefined : null);

            if (third) {

                fn(test);

            } else {

                for (let e = 0; e < 2; e += 1) {

                    arg3 = (e % 2 === 0 ? undefined : null);

                    fn(test);

                }

            }

        }

    }

}

// Tests instantiation of a class with parameters.

function instanceParameters(Klass, fn1, fn2, fn3, third) {

    let arg1, arg2, arg3, test3, args1, args2, args3;

    const test1 = (() => new Klass(arg1));

    const test2 = (() => new Klass(arg1, arg2));

    if (third) {

        test3 = (() => null);

        args1 = [undefined, null, Klass.prototype.message];

        args2 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

        args3 = [];

    } else {

        test3 = (() => new Klass(arg1, arg2, arg3));

        args1 = [undefined, null, Klass.prototype.name];

        args2 = [undefined, null, Klass.prototype.message];

        args3 = [undefined, null, Math.round(Math.random() * 0xFFFFFFFF)];

    }

    for (let i = 0; i < args1.length; i += 1) {

        arg1 = args1[i];

        fn1(test1);

        for (let j = 0; j < args2.length; j += 1) {

            arg2 = args2[j];

            fn2(test2);

            for (let e = 0; !third && e < args3.length; e += 1) {

                arg3 = args3[e];

                fn3(test3);

            }

        }

    }

}

// Loops for each parameter of the Klass constructor.

// If the iteration is even, the parameter is defined.

// If the iteration is odd, the parameter is null.

function instanceDefinedOrNull(Klass, name, message, code, fn1, fn2, fn3, third) {

    for (let i = 0; i < 2; i += 1) {

        const even1   = (i % 2 === 0);

        const arg1    = (even1 ? (third ? message : name) : null);

        const source1 = new Klass(arg1);

        fn1(source1, even1);

        for (let j = 0; j < 2; j += 1) {

            const even2   = (j % 2 === 0);

            const arg2    = (even2 ? (third ? code : message) : null);

            const source2 = new Klass(arg1, arg2);

            fn2(source2, even1, even2);

            for (let e = 0; !third && e < 2; e += 1) {

                const even3   = (e % 2 === 0);

                const arg3    = (even3 ? code : null);

                const source3 = new Klass(arg1, arg2, arg3);

                fn3(source3, even1, even2, even3);

            }

        }

    }

}

// Loops for each parameter of the Klass constructor using wrong types to test Error throwing.

function instanceThrowErrors(Klass, fn1, fn2, fn3, third) {

    let arg1, arg2, arg3, test33, test32, test31, test21, test22, test11, arr;

    if (third) {

        arr = noNmb;

        test33 = test32 = test31 = (() => null);

    } else {

        arr    = noStr;

        test33 = (() => new Klass(arg1, arg2, arg3));

        test32 = (() => new Klass(null, arg2, arg3));

        test31 = (() => new Klass(null, null, arg3));

    }

    test22 = (() => new Klass(arg1, arg2));

    test21 = (() => new Klass(null, arg2));

    test11 = (() => new Klass(arg1));

    for (let i = 0; i < noStr.length; i += 1) {

        arg1 = noStr[i];

        fn1(test11);

        for (let j = 0; j < arr.length; j += 1) {

            arg2 = (third ? noNmb[j] : noStr[j]);

            fn2(test21, test22);

            for (let e = 0; !third && e < noNmb.length; e += 1) {

                arg3 = noNmb[e];

                fn3(test31, test32, test33);

            }

        }

    }

}

// Tests classes that are a third level subclass, meaning that they require 2 arguments (message and code).

// Tests classes that require 3 arguments (name, message and code).

function test(Klass) {

    // :: CONSTRUCTOR

    it("should throw an Error if 'message' or 'code' are invalid parameters", () => {

        instanceThrowErrors(Klass, (test11) => {

            expect(test11).toThrowError("parameter 'name' must be a 'string'");

        }, (test21, test22) => {

            expect(test22).toThrowError("parameter 'name' must be a 'string'");

            expect(test21).toThrowError("parameter 'message' must be a 'string'");

        }, (test31, test32, test33) => {

            expect(test33).toThrowError("parameter 'name' must be a 'string'");

            expect(test32).toThrowError("parameter 'message' must be a 'string'");

            expect(test31).toThrowError("parameter 'code' must be a 'number'");

        }, false);

    });

    // :: MEMBER PROPERTIES

    const code = Math.round(Math.random() * 0xFFFFFFFF);

    it("should have all correct properties once instantiated", () => {

        instanceDefinedOrNull(Klass, name, message, code, (instance, even) => {

            if (even) {

                expect(instance.name).toEqual(name);

                expect(instance.message).toEqual(Klass.prototype.message);

            } else {

                expect(instance.name).toEqual(Klass.prototype.name);

                expect(instance.message).toEqual(Klass.prototype.message);

            }

            expect(instance.code).toBeNull();

        }, (instance, even1, even2) => {

            expect(instance.name).toEqual(even1 ? name : Klass.prototype.name);

            expect(instance.message).toEqual(even2 ? message : Klass.prototype.message);

            expect(instance.code).toBeNull();

        }, (instance, even1, even2, even3) => {

            expect(instance.name).toEqual(even1 ? name : Klass.prototype.name);

            expect(instance.message).toEqual(even2 ? message : Klass.prototype.message);

            expect(instance.code).toEqual(even3 ? code : null);

        }, false);

    });

    // :: MEMBER METHODS

    it("#toString()", () => {

        instanceDefinedOrNull(Klass, name, message, code, (instance, even) => {

            let exp;

            if (even) {

                exp = name + ": " + Klass.prototype.message + '.';

            } else {

                exp = Klass.prototype.name + ": " + Klass.prototype.message + '.';

            }

            expect(instance.toString()).toEqual(exp);

        }, (instance, even1, even2) => {

            let exp;

            exp = (even1 ? name : Klass.prototype.name) + ':';

            exp += ' ' + (even2 ? message : Klass.prototype.message) + '.';

            expect(instance.toString()).toEqual(exp);

        }, (instance, even1, even2, even3) => {

            let exp;

            exp = (even1 ? name : Klass.prototype.name);

            exp += (even3 ? " (0x" + code.toString(16) + "):" : ':') + ' ';

            exp += (even2 ? message : Klass.prototype.message) + '.';

            expect(instance.toString()).toEqual(exp);

        }, false);

    });

    it("#native()", () => {

        instanceDefinedOrNull(Klass, name, message, code, (instance) => {

            const exp = Klass.prototype.message;

            expect(instance.native()).toEqual(new Error(exp));

        }, (instance, even1, even2) => {

            const exp = (even2 ? message : Klass.prototype.message);

            expect(instance.native()).toEqual(new Error(exp));

        }, (instance, even1, even2) => {

            const exp = (even2 ? message : Klass.prototype.message);

            expect(instance.native()).toEqual(new Error(exp));

        }, false);

    });